package com.dtx.stream.practice;

import org.junit.Test;

import java.util.*;
import java.util.stream.Collectors;

public class Demo {

        Trader raoul = new Trader("Raoul","Cambridge");
        Trader mario = new Trader("Mario","Milan");
        Trader alan = new Trader("Alan","Cambridge");
        Trader brain = new Trader("Brain","Cambridge");
        List<Transaction> transactions = Arrays.asList(
                new Transaction(brain, 2011, 300),
                new Transaction(raoul, 2012, 1000),
                new Transaction(raoul, 2011, 400),
                new Transaction(mario, 2012, 710),
                new Transaction(mario, 2012, 700),
                new Transaction(alan, 2012, 950));

        @Test
        public void test(){
        //找出2011年发生的所有交易，并按交易额排序（从低到高）
        List<Transaction> tr2011 = transactions.stream().
                filter(transaction -> transaction.getYear() == 2011) //给filter传递一个谓词来选择2011年的交易
                .sorted(Comparator.comparing(Transaction::getValue)) //按照交易额进行排序
                .collect(Collectors.toList()); //将生成的Stream中所有的元素收集到一个List
        for (Transaction transaction : tr2011) {
            System.out.println(transaction);
            }
        }

        @Test
        public void test1(){
            //交易员都在哪些不同的城市工作过
            List<String> cities = transactions.stream().
                    map(transaction -> transaction.getTrader().getCity()) //提取与交易相关的每位交易员的所在城市
                    .distinct() //只选择互不相同的城市
                    .collect(Collectors.toList());
            Set<String> cities2 = transactions.stream().
                    map(transaction -> transaction.getTrader().getCity())
                    .collect(Collectors.toSet());
            for (String city : cities) {
                System.out.println(city);
            }
        }

        @Test
        public void test2(){
            //查找所有来自于剑桥的交易员，并按姓名排序
            List<Trader> traders = transactions.stream()
                    .map(Transaction::getTrader)  //从交易员提取所有交易员
                    .filter(trader -> trader.getCity().equals("Cambridge")) //仅选择位于剑桥的交易员
                    .distinct() //确保没有任何重复
                    .sorted(Comparator.comparing(Trader::getName)) //对生成的交易员流按照姓名进行排序
                    .collect(Collectors.toList());
            for (Trader trader : traders) {
                System.out.println(trader);
            }
        }

        @Test
        public void test3(){
            //返回所有交易员的姓名字符串，按照字母顺序排序
            String traderStr = transactions.stream()
                    .map(transaction -> transaction.getTrader().getName()) //提取所有交易员姓名，生成一个String构成的Stream
                    .distinct() //只选择不相同的明星
                    .sorted() //对姓名按字母顺序排序
                    .reduce("", (n1, n2) -> n1 + n2);//逐个拼接每个名字，得到一个将所有名字连接起来的String
            System.out.println(traderStr);
        }

        @Test
        public void test4(){
            //有没有交易员是在米兰工作的
            boolean milanBased = transactions.stream().anyMatch(transaction ->
                    transaction.getTrader().getCity().equals("Milan")); //把一个谓词传递给anyMatch，检查是否有交易员在米兰工作
            System.out.println(milanBased);
        }

        @Test
        public void test5(){
            //打印生活在剑桥的交易员的所有交易额
            transactions.stream()
                    .filter(t -> "Cambridge".equals(t.getTrader().getCity())) //选择住在剑桥的交易员所进行的交易
                    .map(Transaction::getValue) //提取这些交易的交易额
                    .forEach(System.out::println); //打印每个值

        }

        @Test
        public void test6(){
            //所有交易中，最高的交易额是多少
            Optional<Integer> highestValue = transactions.stream()
                    .map(Transaction::getValue) //提取每项交易的交易额
                    .reduce(Integer::max);//计算生成的流中的最大值
            System.out.println(highestValue.toString());
        }

        @Test
        public void test7(){
            //找到交易额最小的交易
            Optional<Transaction> smallestTransaction = transactions.stream()
                    .min(Comparator.comparing(Transaction::getValue));
            System.out.println(smallestTransaction.toString());
        }

}
